home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / utility / 252 / gemsrc / window.mod < prev   
Text File  |  1988-02-13  |  27KB  |  797 lines
  1. IMPLEMENTATION MODULE Window;
  2.  
  3.  
  4.    (*$S-,$T- turn off stack and range checking *) 
  5.  
  6.    FROM SYSTEM IMPORT ADR, ADDRESS;
  7.    IMPORT GEMVDIbase;
  8.    IMPORT VDIAttribs;
  9.    IMPORT VDIControls;
  10.    IMPORT VDIOutputs;
  11.    IMPORT GEMAESbase;
  12.    IMPORT AESForms;
  13.    IMPORT AESGraphics;
  14.    IMPORT AESWindows;
  15.    IMPORT Math;
  16.    IMPORT Text;
  17.    IMPORT Screen;
  18.    IMPORT Icon;
  19.  
  20.  
  21.    CONST
  22.       NoWindowLine1 = "[3][No more windows are available.|Before you open a desk|";
  23.       NoWindowLine2 = "accessory, close a window|that you are no longer using.][ OK ]";
  24.  
  25.    VAR WindowList : InformationPtr;
  26.  
  27.       (* Contains pointer to linked list of window information *)
  28.       (* records.                                              *)
  29.  
  30.    (********************************************************************)
  31.  
  32.    PROCEDURE ScreenPointToWindowPoint ( 
  33.                 ScreenPoint     : Screen.PixelCoordinate;
  34.                 WindowOrigin    : Screen.PixelCoordinate;
  35.                 ScreenOrigin    : PixelCoordinate;
  36.                 VAR WindowPoint : PixelCoordinate );
  37.  
  38.    BEGIN
  39.       WindowPoint.X := ScreenPoint.X - WindowOrigin.X + ScreenOrigin.X;
  40.       WindowPoint.Y := ScreenPoint.Y - WindowOrigin.Y + ScreenOrigin.Y;
  41.    END ScreenPointToWindowPoint;
  42.  
  43.    (********************************************************************)
  44.  
  45.    PROCEDURE WindowPointToScreenPoint (
  46.                WindowPoint     : PixelCoordinate;
  47.                ScreenOrigin    : PixelCoordinate;
  48.                WindowOrigin    : Screen.PixelCoordinate;
  49.                VAR ScreenPoint : Screen.PixelCoordinate );
  50.  
  51.    BEGIN
  52.       ScreenPoint.X := WindowPoint.X - ScreenOrigin.X + WindowOrigin.X;
  53.       ScreenPoint.Y := WindowPoint.Y - ScreenOrigin.Y + WindowOrigin.Y;
  54.    END WindowPointToScreenPoint;
  55.  
  56.    (********************************************************************)
  57.  
  58.    PROCEDURE ScreenBoxToWindowBox (
  59.                 ScreenBox     : Screen.Box;
  60.                 WindowOrigin  : Screen.PixelCoordinate;
  61.                 ScreenOrigin  : PixelCoordinate;
  62.                 VAR WindowBox : Box );
  63.  
  64.    BEGIN
  65.       ScreenPointToWindowPoint (
  66.          ScreenBox.Origin, WindowOrigin, ScreenOrigin, WindowBox.Origin );
  67.       WindowBox.Size.Width  := ScreenBox.Size.Width;
  68.       WindowBox.Size.Height := ScreenBox.Size.Height;
  69.    END ScreenBoxToWindowBox;
  70.  
  71.    (********************************************************************)
  72.  
  73.    PROCEDURE WindowBoxToScreenBox (
  74.                 WindowBox     : Box;
  75.                 ScreenOrigin  : PixelCoordinate;
  76.                 WindowOrigin  : Screen.PixelCoordinate;
  77.                 VAR ScreenBox : Screen.Box );
  78.  
  79.    BEGIN
  80.       WindowPointToScreenPoint (
  81.          WindowBox.Origin, ScreenOrigin, WindowOrigin, ScreenBox.Origin );
  82.       ScreenBox.Size.Width  := WindowBox.Size.Width;
  83.       ScreenBox.Size.Height := WindowBox.Size.Height;
  84.    END WindowBoxToScreenBox;
  85.  
  86.    (********************************************************************)
  87.  
  88.    PROCEDURE ContainsPoint ( Point  : PixelCoordinate;
  89.                              Region : Box ) : BOOLEAN;
  90.  
  91.    BEGIN
  92.       RETURN ((Point.X >= Region.Origin.X) AND
  93.               (Point.Y >= Region.Origin.Y) AND
  94.               (Point.X < Region.Origin.X + Region.Size.Width) AND
  95.               (Point.Y < Region.Origin.Y + Region.Size.Height));
  96.    END ContainsPoint;
  97.  
  98.    (********************************************************************)
  99.  
  100.    PROCEDURE Intersected ( Region1     : Box;
  101.                            Region2     : Box;
  102.                            VAR Result  : Box ) : BOOLEAN;
  103.  
  104.       VAR TempResult : Box;
  105.  
  106.    BEGIN
  107.      TempResult.Origin.X :=
  108.         Math.Max ( Region1.Origin.X, Region2.Origin.X );
  109.      TempResult.Origin.Y :=
  110.         Math.Max ( Region1.Origin.Y, Region2.Origin.Y );
  111.      TempResult.Size.Width := 
  112.         Math.Min ( Region1.Size.Width + Region1.Origin.X,
  113.                    Region2.Size.Width + Region2.Origin.X ) -
  114.         TempResult.Origin.X;
  115.      TempResult.Size.Height :=
  116.         Math.Min ( Region1.Size.Height + Region1.Origin.Y,
  117.                    Region2.Size.Height + Region2.Origin.Y ) -
  118.         TempResult.Origin.Y;
  119.      Result := TempResult;
  120.      RETURN ((Result.Size.Width > 0) AND (Result.Size.Height > 0));
  121.    END Intersected;
  122.  
  123.    (********************** LOCAL ROUTINE *******************************)
  124.  
  125.    PROCEDURE SetHorizSliderSize ( TargetWindow : InformationPtr );
  126.  
  127.    VAR SliderSize : INTEGER;
  128.  
  129.    BEGIN
  130.       WITH TargetWindow^ DO
  131.          IF VirtualRegionSize.Width <> 0 THEN
  132.             SliderSize := INTEGER (
  133.                LONGINT (WorkRegion.Size.Width) *
  134.                LONGINT (1000) DIV
  135.                LONGINT (VirtualRegionSize.Width));
  136.             AESWindows.WindowSet (
  137.                Id,
  138.                GEMAESbase.HorizSliderSize,
  139.                SliderSize, 0, 0, 0 );
  140.          END;
  141.       END;
  142.    END SetHorizSliderSize;
  143.  
  144.    (************************** LOCAL ROUTINE ***************************)
  145.  
  146.    PROCEDURE SetHorizSliderPosition ( TargetWindow : InformationPtr );
  147.  
  148.    VAR SliderPosition : INTEGER;
  149.  
  150.    BEGIN
  151.       WITH TargetWindow^ DO
  152.          IF VirtualRegionSize.Width <> 0 THEN
  153.             SliderPosition := INTEGER (
  154.                LONGINT (VirtualOrigin.X) *
  155.                LONGINT (1000) DIV
  156.                LONGINT (VirtualRegionSize.Width));
  157.             AESWindows.WindowSet (
  158.                Id,
  159.                GEMAESbase.WindowHorizSlide,
  160.                SliderPosition,
  161.                0, 0, 0 );
  162.          END;
  163.       END;
  164.    END SetHorizSliderPosition;
  165.  
  166.    (************************** LOCAL ROUTINE ***************************)
  167.  
  168.    PROCEDURE SetVertSliderSize ( TargetWindow : InformationPtr );
  169.  
  170.    VAR SliderSize : INTEGER;
  171.  
  172.    BEGIN
  173.       WITH TargetWindow^ DO
  174.          IF VirtualRegionSize.Height <> 0 THEN
  175.             SliderSize := INTEGER (
  176.                LONGINT (WorkRegion.Size.Height) *
  177.                LONGINT (1000) DIV
  178.                LONGINT (VirtualRegionSize.Height));
  179.             AESWindows.WindowSet (
  180.                Id,
  181.                GEMAESbase.VertSliderSize,
  182.                SliderSize, 0, 0, 0 );
  183.          END;
  184.       END;
  185.    END SetVertSliderSize;
  186.  
  187.    (************************** LOCAL ROUTINE ***************************)
  188.  
  189.    PROCEDURE SetVertSliderPosition ( TargetWindow : InformationPtr );
  190.  
  191.    VAR SliderPosition : INTEGER;
  192.  
  193.    BEGIN
  194.       WITH TargetWindow^ DO
  195.          IF VirtualRegionSize.Height <> 0 THEN
  196.             SliderPosition := INTEGER (
  197.                LONGINT (VirtualOrigin.Y) *
  198.                LONGINT (1000) DIV
  199.                LONGINT (VirtualRegionSize.Height));
  200.             AESWindows.WindowSet (
  201.                Id,
  202.                GEMAESbase.WindowVertSlide,
  203.                SliderPosition,
  204.                0, 0, 0 );
  205.          END;
  206.       END;
  207.    END SetVertSliderPosition;
  208.  
  209.    (********************************************************************)
  210.  
  211.    PROCEDURE Find ( WindowId      : INTEGER;
  212.                     VAR WindowPtr : InformationPtr ) : BOOLEAN;
  213.  
  214.    BEGIN
  215.       WindowPtr := WindowList;
  216.       WHILE (WindowPtr <> NIL) AND (WindowPtr^.Id <> WindowId) DO
  217.          WindowPtr := WindowPtr^.Successor;
  218.       END;
  219.       RETURN (WindowPtr <> NIL);
  220.    END Find;
  221.  
  222.    (********************************************************************)
  223.  
  224.    PROCEDURE Open (
  225.       GrowFromBox             : Screen.Box;
  226.       WindowPtr               : InformationPtr;
  227.       WindowName              : Text.String80;
  228.       WindowInformationLine   : Text.String80;
  229.       WindowRegion            : Screen.Box;
  230.       WindowVirtualRegionSize : Area;
  231.       WindowComponents        : INTEGER;
  232.       WindowFillStyle         : INTEGER;
  233.       WindowFillIndex         : INTEGER;
  234.       WindowContents          : INTEGER;
  235.       WindowRedrawRoutine     : RedrawRoutineType ) : BOOLEAN;
  236.  
  237.    VAR OpenStatus : BOOLEAN;
  238.  
  239.    BEGIN
  240.       OpenStatus := TRUE;  (* Hope that the window can open OK *)
  241.       AESGraphics.GrafMouse ( GEMAESbase.MouseOff, 0 );
  242.  
  243.       (*--- Initialize the data fields of the window to be created ----*)
  244.  
  245.       WITH WindowPtr^ DO
  246.          Name            := WindowName;
  247.          InformationLine := WindowInformationLine;
  248.          Components      := WindowComponents;
  249.          WorkRegion      := WindowRegion;
  250.          AESWindows.WindowCalc (
  251.             GEMAESbase.WCBorder,
  252.             Components,
  253.             WindowRegion.Origin.X,
  254.             WindowRegion.Origin.Y,
  255.             WindowRegion.Size.Width, 
  256.             WindowRegion.Size.Height,
  257.             Borders.Origin.X,
  258.             Borders.Origin.Y,
  259.             Borders.Size.Width,
  260.             Borders.Size.Height );
  261.          BackdropFillStyle := WindowFillStyle;
  262.          BackdropFillIndex := WindowFillIndex;
  263.          BackdropContents  := WindowContents;
  264.          VirtualRegionSize := WindowVirtualRegionSize;
  265.          VirtualOrigin.X   := 0;
  266.          VirtualOrigin.Y   := 0;
  267.          RedrawRoutine     := WindowRedrawRoutine;
  268.  
  269.          (*--- Create the new window ----------------------------------*)
  270.  
  271.          Id := AESWindows.WindowCreate (
  272.             Components,
  273.             Borders.Origin.X,
  274.             Borders.Origin.Y,
  275.             Borders.Size.Width,
  276.             Borders.Size.Height );
  277.          IF Id < 0 THEN
  278.             OpenStatus := FALSE;
  279.          ELSE
  280.             IF WindowList <> NIL THEN
  281.                WindowList^.Predecessor := WindowPtr;
  282.             END;
  283.             Successor   := WindowList;
  284.             Predecessor := NIL;
  285.             WindowList  := WindowPtr;
  286.             AESWindows.WindowSet (
  287.                Id,
  288.                GEMAESbase.WindowName,
  289.                INTEGER (ADR (Name) DIV 10000H),
  290.                INTEGER (ADR (Name) MOD 10000H),
  291.                0, 0 );
  292.             AESWindows.WindowSet (
  293.                Id,
  294.                GEMAESbase.WindowInfo,
  295.                INTEGER (ADR (InformationLine) DIV 10000H),
  296.                INTEGER (ADR (InformationLine) MOD 10000H),
  297.                0, 0 );
  298.             SetHorizSliderSize ( WindowPtr );
  299.             SetVertSliderSize ( WindowPtr );
  300.             IF BackdropContents >= 0 THEN
  301.                Icon.SetOrigin ( BackdropContents, 0, WorkRegion.Origin );
  302.             END;
  303.  
  304.             (*--- Display the new window on the screen ----------------*)
  305.  
  306.             AESGraphics.GrafGrowBox (
  307.                GrowFromBox.Origin.X,
  308.                GrowFromBox.Origin.Y,
  309.                GrowFromBox.Size.Width,
  310.                GrowFromBox.Size.Height,
  311.                Borders.Origin.X,
  312.                Borders.Origin.Y,
  313.                Borders.Size.Width,
  314.                Borders.Size.Height );
  315.             AESWindows.WindowOpen (
  316.                Id,
  317.                Borders.Origin.X,
  318.                Borders.Origin.Y,
  319.                Borders.Size.Width,
  320.                Borders.Size.Height );
  321.          END;
  322.       END;
  323.       AESGraphics.GrafMouse ( GEMAESbase.MouseOn, 0 );
  324.       RETURN (OpenStatus);
  325.    END Open;
  326.  
  327.    (********************************************************************)
  328.  
  329.    PROCEDURE Redraw ( WindowId : INTEGER;
  330.                       Region   : Screen.Box );
  331.  
  332.    CONST ClippingOn = 1;
  333.  
  334.    VAR
  335.       TargetWindow    : InformationPtr;
  336.       WindowRectangle : Screen.Box;
  337.       UpdateBox       : Screen.Box;
  338.       FillStyle       : INTEGER;
  339.       FillIndex       : INTEGER;
  340.       PxyArray        : GEMVDIbase.PxyArrayType;
  341.       PreviousRegion  : Screen.Box;
  342.  
  343.    BEGIN
  344.       IF Find ( WindowId, TargetWindow ) THEN
  345.  
  346.          (*--- Window belongs to application, so redraw it ------------*)
  347.  
  348.          AESGraphics.GrafMouse ( GEMAESbase.MouseOff, 0 );
  349.          AESWindows.WindowUpdate ( GEMAESbase.BeginUpdate );
  350.          WITH TargetWindow^ DO
  351.            AESWindows.WindowGet (
  352.               Id,
  353.               GEMAESbase.FirstXYWH,
  354.               WindowRectangle.Origin.X,
  355.               WindowRectangle.Origin.Y,
  356.               WindowRectangle.Size.Width,
  357.               WindowRectangle.Size.Height );
  358.            WHILE (WindowRectangle.Size.Width <> 0) AND
  359.                  (WindowRectangle.Size.Height <> 0) DO
  360.  
  361.               (*--- Interate through the update rectangles ------------*)
  362.  
  363.               IF Screen.Intersection (
  364.                     Region,
  365.                     WindowRectangle,
  366.                     UpdateBox ) AND
  367.                  Screen.Intersection (
  368.                     Screen.WorkSpace,
  369.                     UpdateBox,
  370.                     UpdateBox ) THEN
  371.  
  372.                  (*--- "White Out" the area to be redrawn -------------*)
  373.  
  374.                  FillStyle := VDIAttribs.SetFillInteriorStyle (
  375.                     Screen.VirtualHandle, BackdropFillStyle );
  376.                  FillIndex := VDIAttribs.SetFillStyle (
  377.                     Screen.VirtualHandle, BackdropFillIndex );
  378.                  PxyArray[0] := UpdateBox.Origin.X;
  379.                  PxyArray[1] := UpdateBox.Origin.Y;
  380.                  PxyArray[2] := PxyArray[0] + UpdateBox.Size.Width - 1;
  381.                  PxyArray[3] := PxyArray[1] + UpdateBox.Size.Height - 1;
  382.                  VDIControls.SetClipping (
  383.                     Screen.VirtualHandle, ClippingOn, PxyArray );
  384.                  VDIOutputs.FillRectangle (
  385.                     Screen.VirtualHandle, PxyArray );
  386.                  IF BackdropContents >= 0 THEN
  387.                     Icon.GetRegion ( BackdropContents, 0, PreviousRegion );
  388.                     Icon.SetOrigin ( BackdropContents, 0, WorkRegion.Origin );
  389.                     Icon.Display   ( BackdropContents, 0, UpdateBox );
  390.                     Icon.SetOrigin ( BackdropContents, 0, PreviousRegion.Origin );
  391.                  END;  
  392.  
  393.                  (*--- Call the application's redraw routine ----------*)
  394.  
  395.                  RedrawRoutine ( UpdateBox );
  396.               END;
  397.  
  398.               (*--- Get the next update rectangle ---------------------*)
  399.  
  400.               AESWindows.WindowGet (
  401.                  Id,
  402.                  GEMAESbase.NextXYWH,
  403.                  WindowRectangle.Origin.X,
  404.                  WindowRectangle.Origin.Y,
  405.                  WindowRectangle.Size.Width,
  406.                  WindowRectangle.Size.Height );
  407.            END;
  408.            AESWindows.WindowUpdate ( GEMAESbase.EndUpdate );
  409.            AESGraphics.GrafMouse ( GEMAESbase.MouseOn, 0 );
  410.          END;
  411.       END;
  412.    END Redraw;
  413.  
  414.    (********************************************************************)
  415.  
  416.    PROCEDURE Top ( WindowId : INTEGER );
  417.  
  418.    VAR TargetWindow : InformationPtr;
  419.  
  420.    BEGIN
  421.       IF Find ( WindowId, TargetWindow ) THEN
  422.          WITH TargetWindow^ DO
  423.             IF BackdropContents >= 0 THEN
  424.                Icon.SetOrigin ( BackdropContents, 0, WorkRegion.Origin );
  425.             END;
  426.             AESWindows.WindowSet ( Id, GEMAESbase.Top, 0, 0, 0, 0 );
  427.          END;
  428.       END;
  429.    END Top;
  430.  
  431.    (********************************************************************)
  432.  
  433.    PROCEDURE Resize ( WindowId : INTEGER;
  434.                       NewSize  : Screen.Box );
  435.  
  436.    VAR TargetWindow : InformationPtr;
  437.  
  438.    BEGIN
  439.       IF Find ( WindowId, TargetWindow ) THEN
  440.          WITH TargetWindow^ DO
  441.             Borders := NewSize;
  442.             AESWindows.WindowCalc (
  443.                GEMAESbase.WCWork,
  444.                Components,
  445.                Borders.Origin.X,
  446.                Borders.Origin.Y,
  447.                Borders.Size.Width,
  448.                Borders.Size.Height,
  449.                WorkRegion.Origin.X,
  450.                WorkRegion.Origin.Y,
  451.                WorkRegion.Size.Width,
  452.                WorkRegion.Size.Height );
  453.             IF BackdropContents >= 0 THEN
  454.                Icon.SetOrigin ( BackdropContents, 0, WorkRegion.Origin );
  455.             END;
  456.             AESWindows.WindowSet (
  457.                Id,
  458.                GEMAESbase.CurrXYWH,
  459.                Borders.Origin.X,
  460.                Borders.Origin.Y,
  461.                Borders.Size.Width,
  462.                Borders.Size.Height );
  463.             SetHorizSliderSize ( TargetWindow );
  464.             SetVertSliderSize ( TargetWindow );
  465.          END;
  466.       END;
  467.    END Resize;
  468.  
  469.    (********************************************************************)
  470.  
  471.    PROCEDURE Move ( WindowId  : INTEGER;
  472.                     NewOrigin : Screen.PixelCoordinate );
  473.  
  474.    VAR TargetWindow : InformationPtr;
  475.  
  476.    BEGIN
  477.       IF Find ( WindowId, TargetWindow ) THEN
  478.          WITH TargetWindow^ DO
  479.             Borders.Origin := NewOrigin;
  480.             AESWindows.WindowCalc (
  481.                GEMAESbase.WCWork,
  482.                Components,
  483.                Borders.Origin.X,
  484.                Borders.Origin.Y,
  485.                Borders.Size.Width,
  486.                Borders.Size.Height,
  487.                WorkRegion.Origin.X,
  488.                WorkRegion.Origin.Y,
  489.                WorkRegion.Size.Width,
  490.                WorkRegion.Size.Height );
  491.             IF BackdropContents >= 0 THEN
  492.                Icon.SetOrigin ( BackdropContents, 0, WorkRegion.Origin );
  493.             END;
  494.             AESWindows.WindowSet (
  495.                Id,
  496.                GEMAESbase.CurrXYWH,
  497.                Borders.Origin.X,
  498.                Borders.Origin.Y,
  499.                Borders.Size.Width,
  500.                Borders.Size.Height );
  501.          END;
  502.       END;
  503.    END Move;
  504.  
  505.    (********************************************************************)
  506.  
  507.    PROCEDURE Full ( WindowId : INTEGER );
  508.  
  509.    VAR
  510.       TargetWindow    : InformationPtr;
  511.       PreviousWorkBox : Screen.Box;
  512.  
  513.    BEGIN
  514.       IF Find ( WindowId, TargetWindow ) THEN
  515.          WITH TargetWindow^ DO
  516.             IF (Borders.Size.Height = Screen.WorkSpace.Size.Height) AND
  517.                   (Borders.Size.Width = Screen.WorkSpace.Size.Width) THEN
  518.                AESWindows.WindowGet (
  519.                   Id,
  520.                   GEMAESbase.PrevXYWH,
  521.                   PreviousWorkBox.Origin.X,
  522.                   PreviousWorkBox.Origin.Y,
  523.                   PreviousWorkBox.Size.Width,
  524.                   PreviousWorkBox.Size.Height );
  525.                Resize ( Id, PreviousWorkBox );
  526.                AESGraphics.GrafShrinkBox (
  527.                   Screen.WorkSpace.Origin.X,
  528.                   Screen.WorkSpace.Origin.Y,
  529.                   Screen.WorkSpace.Size.Width,
  530.                   Screen.WorkSpace.Size.Height,
  531.                   PreviousWorkBox.Origin.X,
  532.                   PreviousWorkBox.Origin.Y,
  533.                   PreviousWorkBox.Size.Width,
  534.                   PreviousWorkBox.Size.Height );
  535.             ELSE
  536.                AESGraphics.GrafGrowBox (
  537.                   Borders.Origin.X,
  538.                   Borders.Origin.Y,
  539.                   Borders.Size.Width,
  540.                   Borders.Size.Height,
  541.                   Screen.WorkSpace.Origin.X,
  542.                   Screen.WorkSpace.Origin.Y,
  543.                   Screen.WorkSpace.Size.Width,
  544.                   Screen.WorkSpace.Size.Height );
  545.                Resize ( Id, Screen.WorkSpace );
  546.             END;
  547.          END;
  548.       END;
  549.    END Full;
  550.  
  551.    (********************************************************************)
  552.  
  553.    PROCEDURE MoveDisplayArea ( WindowId  : INTEGER;
  554.                                Direction : INTEGER );
  555.  
  556.    CONST
  557.       PageUp      = 0;
  558.       PageDown    = 1;
  559.       RowUp       = 2;
  560.       RowDown     = 3;
  561.       PageLeft    = 4;
  562.       PageRight   = 5;
  563.       ColumnLeft  = 6;
  564.       ColumnRight = 7;
  565.  
  566.    VAR
  567.       TargetWindow   : InformationPtr;
  568.       SliderPosition : INTEGER;
  569.  
  570.    BEGIN
  571.       IF Find ( WindowId, TargetWindow ) THEN
  572.          WITH TargetWindow^ DO
  573.  
  574.             IF Direction = PageUp THEN
  575.                VirtualOrigin.Y := Math.Max (
  576.                   VirtualOrigin.Y - WorkRegion.Size.Height - 10,
  577.                   0 );
  578.                SetVertSliderPosition ( TargetWindow );
  579.  
  580.             ELSIF Direction = PageDown THEN
  581.                VirtualOrigin.Y := Math.Min (
  582.                   VirtualOrigin.Y + WorkRegion.Size.Height - 10,
  583.                   VirtualRegionSize.Height );
  584.                SetVertSliderPosition ( TargetWindow );
  585.  
  586.             ELSIF Direction = RowUp THEN
  587.                VirtualOrigin.Y := Math.Max (
  588.                   VirtualOrigin.Y - Screen.CharacterArea.Height,
  589.                   0 );
  590.                SetVertSliderPosition ( TargetWindow );
  591.  
  592.             ELSIF Direction = RowDown THEN
  593.                VirtualOrigin.Y := Math.Min (
  594.                   VirtualOrigin.Y + Screen.CharacterArea.Height,
  595.                   VirtualRegionSize.Height );
  596.                SetVertSliderPosition ( TargetWindow );
  597.  
  598.             ELSIF Direction = PageLeft THEN
  599.                VirtualOrigin.X := Math.Max (
  600.                   VirtualOrigin.X - WorkRegion.Size.Width - 10,
  601.                   0 );
  602.                SetHorizSliderPosition ( TargetWindow );
  603.  
  604.             ELSIF Direction = PageRight THEN
  605.                VirtualOrigin.X := Math.Min (
  606.                   VirtualOrigin.X + WorkRegion.Size.Width - 10,
  607.                   VirtualRegionSize.Width );
  608.                SetHorizSliderPosition ( TargetWindow );
  609.  
  610.             ELSIF Direction = ColumnLeft THEN
  611.                VirtualOrigin.X := Math.Max (
  612.                   VirtualOrigin.X - Screen.CharacterArea.Width,
  613.                   0 );
  614.                SetHorizSliderPosition ( TargetWindow );
  615.  
  616.             ELSIF Direction = ColumnRight THEN
  617.                VirtualOrigin.X := Math.Min (
  618.                   VirtualOrigin.X + Screen.CharacterArea.Width,
  619.                   VirtualRegionSize.Width );
  620.                SetHorizSliderPosition ( TargetWindow );
  621.  
  622.             END;
  623.             Redraw ( Id, WorkRegion );
  624.          END;
  625.       END;
  626.    END MoveDisplayArea;
  627.  
  628.    (********************************************************************)
  629.  
  630.    PROCEDURE MoveHorizSlider ( WindowId    : INTEGER; 
  631.                                NewPosition : INTEGER );
  632.  
  633.    VAR TargetWindow : InformationPtr;
  634.  
  635.    BEGIN
  636.       IF Find ( WindowId, TargetWindow ) THEN
  637.          WITH TargetWindow^ DO
  638.             AESWindows.WindowSet (
  639.                Id,
  640.                GEMAESbase.WindowHorizSlide,
  641.                NewPosition, 0, 0, 0 );
  642.             VirtualOrigin.X := INTEGER (
  643.                LONGINT (NewPosition) *
  644.                LONGINT (VirtualRegionSize.Width) DIV
  645.                LONGINT (1000));
  646.          END;
  647.       END;
  648.    END MoveHorizSlider;
  649.  
  650.    (********************************************************************)
  651.  
  652.    PROCEDURE MoveVertSlider ( WindowId    : INTEGER;
  653.                               NewPosition : INTEGER );
  654.  
  655.    VAR TargetWindow : InformationPtr;
  656.  
  657.    BEGIN
  658.       IF Find ( WindowId, TargetWindow ) THEN
  659.          WITH TargetWindow^ DO
  660.             AESWindows.WindowSet (
  661.                Id,
  662.                GEMAESbase.WindowVertSlide,
  663.                NewPosition, 0, 0, 0 );
  664.             VirtualOrigin.X := INTEGER (
  665.                LONGINT (NewPosition) *
  666.                LONGINT (VirtualRegionSize.Height) DIV
  667.                LONGINT (1000));
  668.          END;
  669.       END;
  670.    END  MoveVertSlider;
  671.  
  672.    (********************************************************************)
  673.  
  674.    PROCEDURE SetVirtualRegionSize ( WindowId : INTEGER;
  675.                                     Size     : Area );
  676.  
  677.    VAR TargetWindow : InformationPtr;
  678.  
  679.    CONST
  680.       VertSlider  = 8;
  681.       HorizSlider = 11;
  682.  
  683.    BEGIN
  684.       IF Find ( WindowId, TargetWindow ) THEN
  685.          WITH TargetWindow^ DO
  686.             VirtualRegionSize := Size;
  687.             IF HorizSlider IN BITSET (Components) THEN
  688.                SetHorizSliderSize ( TargetWindow );
  689.             END;
  690.             IF VertSlider IN BITSET (Components) THEN 
  691.                SetVertSliderSize ( TargetWindow );
  692.             END;
  693.          END;
  694.       END;  
  695.    END SetVirtualRegionSize;
  696.  
  697.    (********************************************************************)
  698.  
  699.    PROCEDURE ChangeName ( WindowId   : INTEGER;
  700.                           WindowName : Text.String80 );
  701.  
  702.    VAR TargetWindow : InformationPtr;
  703.  
  704.    BEGIN
  705.       IF Find ( WindowId, TargetWindow ) THEN
  706.          WITH TargetWindow^ DO
  707.             Name := WindowName;
  708.             AESWindows.WindowSet (
  709.                Id,
  710.                GEMAESbase.WindowName,
  711.                INTEGER (ADR (Name) DIV 10000H),
  712.                INTEGER (ADR (Name) MOD 10000H),
  713.                0, 0 );
  714.          END;
  715.       END;
  716.    END ChangeName;
  717.  
  718.    (********************************************************************)
  719.  
  720.    PROCEDURE ChangeInformationLine (
  721.                 WindowId              : INTEGER;
  722.                 WindowInformationLine : Text.String80 );
  723.  
  724.    VAR TargetWindow : InformationPtr;
  725.  
  726.    BEGIN
  727.       IF Find ( WindowId, TargetWindow ) THEN
  728.          WITH TargetWindow^ DO
  729.             InformationLine := WindowInformationLine;
  730.          AESWindows.WindowSet (
  731.             Id,
  732.             GEMAESbase.WindowInfo,
  733.             INTEGER (ADR (InformationLine) DIV 10000H),
  734.             INTEGER (ADR (InformationLine) MOD 10000H),
  735.             0, 0 );
  736.          END;
  737.       END;
  738.    END ChangeInformationLine;
  739.  
  740.    (********************************************************************)
  741.  
  742.    PROCEDURE Close (
  743.       WindowId    : INTEGER;
  744.       ShrinkToBox : Screen.Box );
  745.  
  746.    VAR TargetWindow  : InformationPtr;
  747.  
  748.    BEGIN
  749.       IF Find ( WindowId, TargetWindow ) THEN
  750.          WITH TargetWindow^ DO
  751.             AESWindows.WindowClose ( Id );
  752.             AESGraphics.GrafShrinkBox (
  753.                ShrinkToBox.Origin.X,
  754.                ShrinkToBox.Origin.Y,
  755.                ShrinkToBox.Size.Width,
  756.                ShrinkToBox.Size.Height,
  757.                Borders.Origin.X,
  758.                Borders.Origin.Y,
  759.                Borders.Size.Width,
  760.                Borders.Size.Height );
  761.             AESWindows.WindowDelete ( Id );
  762.             Id := -1;
  763.             IF TargetWindow = WindowList THEN
  764.                WindowList := Successor;
  765.             END;
  766.             IF Successor <> NIL THEN
  767.                Successor^.Predecessor := Predecessor;
  768.             END;
  769.             IF Predecessor <> NIL THEN
  770.                Predecessor^.Successor := Successor;
  771.             END;
  772.          END;
  773.       ELSIF WindowId = 0 THEN
  774.          WindowList := NIL;   (* Unconditionally delete all windows *)
  775.       END;
  776.    END Close;
  777.  
  778.    (********************************************************************)
  779.  
  780.    PROCEDURE Unavailable;
  781.  
  782.    VAR
  783.       Buffer     : ARRAY [0..400] OF CHAR;
  784.       Success    : BOOLEAN;
  785.       ExitObject : INTEGER;
  786.  
  787.    BEGIN
  788.       Buffer     := NoWindowLine1;
  789.       Success    := Text.ConcatString ( Buffer, NoWindowLine2, Buffer );
  790.       ExitObject := AESForms.FormAlert ( 1, Buffer ); 
  791.    END Unavailable;
  792.  
  793. BEGIN
  794.    WindowList := NIL;
  795. END Window.
  796.  
  797.